home *** CD-ROM | disk | FTP | other *** search
/ The Fatted Calf / The Fatted Calf.iso / Applications / Audio / Patchmix / Source / Pluck.m < prev    next >
Text File  |  1992-08-18  |  5KB  |  228 lines
  1.  
  2. /* Generated by Interface Builder */
  3.  
  4. #import "Pluck.h"
  5. #import "Instrum.h"
  6. #import <appkit/graphics.h>
  7. #import "Statement.h"
  8.  
  9. @implementation Pluck
  10.  
  11. + initialize
  12. {
  13.        image = [NXImage findImageNamed:"Pluck"];
  14.     dynamOffset.x = 3;
  15.     dynamOffset.y = 30;
  16.     ampOffset.x = 30;
  17.     ampOffset.y = 52;
  18.     freqOffset.x = 52;
  19.     freqOffset.y = 30;
  20.     outOffset.x = 30;
  21.     outOffset.y = 8;
  22.     
  23.     return self;
  24. }
  25.  
  26. - init
  27. {
  28.     written = NO;
  29.     size.width = 80.;
  30.     size.height = 80.;
  31.     center.x = size.width/2.;
  32.     center.y = size.height/2.;
  33.     strcpy(type,"Pluck");
  34.     strcpy(name,"hpluck");
  35.     
  36.     dynam = [[Param alloc] init:self :&dynamOffset];
  37.     amp = [[Param alloc] init:self :&Offset];
  38.     freq = [[Param alloc] init:self :&freqOffset];
  39.     out = [[Param alloc] init:self :&outOffset];
  40.  
  41.     [freq setValue:"440"];    
  42.     [dynam setTitle:"Dynam:"];
  43.     [amp setTitle:"Amp:"];
  44.     [freq setTitle:"Freq:"];
  45.     [out setTitle:"Out:"];
  46.  
  47.     paramList = [[List alloc] initCount:4];
  48.     [paramList addObject:dynam];
  49.     [paramList addObject:amp];
  50.     [paramList addObject:freq];
  51.     [paramList addObject:out];
  52.     
  53.     [Inst putUgenInList:self];
  54.     
  55.     return self;
  56. }
  57.  
  58. - remove
  59. {
  60.     id cp,param;
  61.     int i;
  62.                             // make sure not connected first 
  63.     for(i = 0; i < ([paramList count]); i++) {    
  64.         param = [paramList objectAt:i];
  65.         if(cp = [param getConnectedParam]) 
  66.             return 0;
  67.     }
  68.                             // remove ugen from list
  69.     [Inst removeUgenFromList:self];
  70.     return self;
  71. }
  72.  
  73. - (NXImage *)getImage
  74. {
  75.     return image;
  76. }
  77.  
  78. - move:(NXPoint *)newloc
  79. {
  80.     location = *newloc;
  81.     [dynam move:&location];
  82.     [amp move:&location];
  83.     [freq move:&location];
  84.     [out move:&location];
  85.     return self;
  86. }
  87.  
  88. - findParamAtPoint:(NXPoint *)point
  89. {
  90.     NXRect *rect;
  91.     int i;
  92.     id param;
  93.     
  94.     for(i = 0; i < [paramList count]; i++) {
  95.         param = [paramList objectAt:i];
  96.         rect = [param getRect];
  97.         if(NXMouseInRect(point,rect,NO))
  98.             return param;
  99.     }
  100.     return nil;
  101. }
  102.  
  103. - writeUgen
  104. {
  105.     /*     for amp param:
  106.             see if there is input ugen - (not yet -- add pluckin stuff later)
  107.                 if so, grab the output (ug?) and multiply it by this
  108.                     param value
  109.                 if not just use the param value
  110.          after all params done, write relevant code into lists
  111.             (declarations, assignments and loop statements)
  112.             i.e. ug? = oscil(,,,,);
  113.         go to output param connected ugen and call its "writeUgen"
  114.     */
  115.     BOOL rm;
  116.     char ampVar[10];
  117.     int i;
  118.     int parent[3];
  119.     id param;
  120.     id ug;
  121.     id nupar;
  122.     char str[50];
  123.     char par[20];
  124.     
  125.     //printf("writing ugen %d\n",index);
  126.     sprintf(str,"\tfloat ug%d;\n",index);
  127.     [Inst putVarInList:str];
  128.     sprintf(str,"\tfloat dynam%d;\n",index);
  129.     [Inst putVarInList:str];
  130.     sprintf(str,"\tfloat amp%d;\n",index);
  131.     [Inst putVarInList:str];
  132.     sprintf(str,"\tfloat freq%d;\n",index);
  133.     [Inst putVarInList:str];
  134.     sprintf(str,"\tfloat out%d;\n",index);
  135.     [Inst putVarInList:str];
  136.     sprintf(str,"\tfloat loopt%d;\n",index);
  137.     [Inst putVarInList:str];
  138.     sprintf(str,"\tfloat  *q%d;\n",index);
  139.     [Inst putVarInList:str];
  140.  
  141.     for(i = 0; i < ([paramList count]-1); i++) {    
  142.         param = [paramList objectAt:i];
  143.         if(nupar = [param getConnectedParam]) {
  144.             ug = [nupar getUgen];
  145.             if([ug getWritten] == NO) { 
  146.                 parent[i] = [[ug writeUgen] getIndex];
  147.             }
  148.             else  {
  149.                 parent[i] = 0;
  150.             }
  151.         }
  152.         else 
  153.             parent[i] = 0;
  154.         
  155.     }
  156.  
  157. /*    
  158.     if(parent[0]) {     // amplitude input ugen    
  159.         rm = YES;
  160.         sprintf(str,"\t\tamp%d = %.2f;\n",index, 
  161.             atof([[paramList objectAt:0] getValue]));
  162.         [Inst putLoopInList:str];
  163.         sprintf(str,"\tfloat amprm%d;\n",index);
  164.         [Inst putVarInList:str];
  165.         sprintf(str,"\t\tamprm%d = amp%d * ug%d;\n",index,  
  166.             index,parent[0]);
  167.         [Inst putLoopInList:str];
  168.     }
  169.     else {                // amp preset or default
  170. */
  171.         rm = NO;
  172.         //printf("amp preset or default\n");
  173.         sprintf(str,"\tamp%d = %.2f;\n",index,atof([[paramList objectAt:1] getValue]));
  174.         [Inst putAssignInList:str];
  175. //    }
  176.     
  177. //    if(rm)
  178. //        sprintf(ampVar,"amprm%d",index);
  179. //    else
  180.         sprintf(ampVar,"amp%d",index);
  181.         
  182.                     // dynam:
  183.     strcpy(par,[[paramList objectAt:0] getValue]);
  184.     if(par[0] == 'p' && par[1] == '[')
  185.         sprintf(str,"\tdynam%d = %s;\n",index,par);
  186.     else
  187.         sprintf(str,"\tdynam%d = %.2f;\n", index, atof([[paramList objectAt:0] getValue]));
  188.     [Inst putAssignInList:str];
  189.  
  190.                                 // pitch
  191.     strcpy(par,[[paramList objectAt:2] getValue]);
  192.     if(par[0] == 'p' && par[1] == '[')
  193.         sprintf(str,"\tloopt%d = 1/%s;\n", index, par);
  194.     else
  195.         sprintf(str,"\tloopt%d = 1/%.2f;\n", index, atof(par));
  196.     [Inst putAssignInList:str];
  197.  
  198.                     // output amplitude multiplier:
  199.     strcpy(par,[[paramList objectAt:3] getValue]);
  200.     if(par[0] == 'p' && par[1] == '[')
  201.         sprintf(str,"\tout%d = %s;\n",index,par);
  202.     else
  203.         sprintf(str,"\tout%d = %.2f;\n", index, atof([[paramList objectAt:3] getValue]));
  204.     [Inst putAssignInList:str];
  205.  
  206.                         //     allocate memory for q array
  207.     sprintf(str,"\tif((q%d = (float *)malloc((int)((loopt%d*SR+20) *  4))) == 0) {\n", index, index);
  208.     [Inst putAssignInList:str];
  209.     sprintf(str,"\t\tprintf(\"can't malloc memory for delayline\");\n\t\texit(-1);\n\t}\n");
  210.     [Inst putAssignInList:str];
  211.     
  212.                         //     set up pluck
  213.                         //        hplset(loopt,realpluckdur,dynam,pluckamp,seed,SR,1,q)
  214.     sprintf(str, "\thplset(loopt%d,p[1],dynam%d,amp%d,0.414,SR,1,q%d);\n",index,index,index, index);
  215.     [Inst putAssignInList:str];
  216.  
  217.     sprintf(str,"\t\tug%d = %s(0., q%d)*out%d;\n", index, name, index, index);
  218.     [Inst putLoopInList:str];
  219.     
  220.     sprintf(str,"\tfree(q%d);\n", index);
  221.     [Inst putEndInList:str];
  222.  
  223.     written = YES;
  224.     return self;    
  225. }
  226.  
  227. @end
  228.